/**
 * 工具函数集合
 *
 * @example
 * // 基本使用 - 过滤空值
 * const params = {
 *   name: 'John',
 *   age: 25,
 *   email: '',
 *   phone: null,
 *   address: undefined,
 *   tags: []
 * };
 *
 * const filteredParams = createRequestParams(params);
 * // 结果: { name: 'John', age: 25 }
 *
 * @example
 * // 自定义过滤规则
 * const customParams = filterEmptyValues(params, {
 *   filterZero: true,        // 过滤 0
 *   filterFalse: true,       // 过滤 false
 *   customFilter: (value, key) => {
 *     // 自定义过滤逻辑
 *     return key !== 'secret' && value !== 'hidden';
 *   }
 * });
 */

export function transformToField<T extends Record<string, any>>(
  target: T[],
  type: 'string' | 'number' | 'boolean',
  fields: string[],
): T[] {
  return target.map((item) => {
    const newItem: any = { ...item };
    fields.forEach((field) => {
      if (field in newItem) {
        switch (type) {
          case 'string':
            newItem[field] = String(newItem[field]);
            break;
          case 'number':
            newItem[field] = Number(newItem[field]);
            break;
          case 'boolean':
            newItem[field] = Boolean(newItem[field]);
            break;
        }
      }
    });
    return newItem;
  });
}

/**
 * 过滤对象中的空值字段
 * @param obj 要过滤的对象
 * @param options 过滤选项
 * @returns 过滤后的对象
 */
export function filterEmptyValues<T extends Record<string, any>>(
  obj: T,
  options: {
    /** 是否过滤空字符串，默认 true */
    filterEmptyString?: boolean;
    /** 是否过滤 null，默认 true */
    filterNull?: boolean;
    /** 是否过滤 undefined，默认 true */
    filterUndefined?: boolean;
    /** 是否过滤 0，默认 false */
    filterZero?: boolean;
    /** 是否过滤 false，默认 false */
    filterFalse?: boolean;
    /** 是否过滤空数组，默认 true */
    filterEmptyArray?: boolean;
    /** 是否过滤空对象，默认 true */
    filterEmptyObject?: boolean;
    /** 自定义过滤函数 */
    customFilter?: (value: any, key: string) => boolean;
  } = {},
): Partial<T> {
  const {
    filterEmptyString = true,
    filterNull = true,
    filterUndefined = true,
    filterZero = false,
    filterFalse = false,
    filterEmptyArray = true,
    filterEmptyObject = true,
    customFilter,
  } = options;

  const result: Partial<T> = {};

  for (const [key, value] of Object.entries(obj)) {
    // 如果提供了自定义过滤函数，优先使用
    if (customFilter && !customFilter(value, key)) {
      continue;
    }

    // 过滤 null
    if (filterNull && value === null) {
      continue;
    }

    // 过滤 undefined
    if (filterUndefined && value === undefined) {
      continue;
    }

    // 过滤空字符串
    if (filterEmptyString && value === '') {
      continue;
    }

    // 过滤 0
    if (filterZero && value === 0) {
      continue;
    }

    // 过滤 false
    if (filterFalse && value === false) {
      continue;
    }

    // 过滤空数组
    if (filterEmptyArray && Array.isArray(value) && value.length === 0) {
      continue;
    }

    // 过滤空对象
    if (
      filterEmptyObject &&
      typeof value === 'object' &&
      value !== null &&
      !Array.isArray(value) &&
      Object.keys(value).length === 0
    ) {
      continue;
    }

    // 保留该字段
    result[key as keyof T] = value;
  }

  return result;
}

/**
 * 测试用例示例：
 *
 * // 测试基本过滤功能
 * const testParams = {
 *   name: 'John',
 *   age: 25,
 *   email: '',
 *   phone: null,
 *   address: undefined,
 *   isActive: false,
 *   score: 0,
 *   tags: [],
 *   config: {}
 * };
 *
 * const result = createRequestParams(testParams);
 * console.log(result);
 * // 输出: { name: 'John', age: 25, isActive: false, score: 0 }
 *
 * // 测试自定义过滤
 * const customResult = filterEmptyValues(testParams, {
 *   filterZero: true,
 *   filterFalse: true
 * });
 * console.log(customResult);
 * // 输出: { name: 'John', age: 25 }
 */

/**
 * 将对象格式的映射转换为数组格式的选项
 * @param map 对象格式的映射 {key: value}
 * @param options 转换选项
 * @returns 数组格式的选项 [{label: value, value: key}]
 *
 * @example
 * // 基本使用
 * const ORDER_STATUS_MAP = {
 *   1: '官网订单',
 *   2: '后台订单'
 * };
 *
 * const ORDER_STATUS_OPTIONS = mapToOptions(ORDER_STATUS_MAP);
 * // 结果: [
 * //   { label: '官网订单', value: 1 },
 * //   { label: '后台订单', value: 2 }
 * // ]
 *
 * @example
 * // 自定义 key 和 label 字段名
 * const options = mapToOptions(ORDER_STATUS_MAP, {
 *   valueKey: 'id',
 *   labelKey: 'name'
 * });
 * // 结果: [
 * //   { name: '官网订单', id: 1 },
 * //   { name: '后台订单', id: 2 }
 * // ]
 */
export function mapToOptions<T extends Record<string | number, any>>(
  map: T,
  options: {
    valueKey?: string;
    labelKey?: string;
    sortBy?: 'key' | 'value' | 'none';
    filter?: (key: string | number, value: any) => boolean;
  } = {},
): Array<{ [key: string]: any }> {
  const { valueKey = 'value', labelKey = 'label', sortBy = 'none', filter = () => true } = options;

  // 转换为数组格式
  let result = Object.entries(map)
    .filter(([key, value]) => filter(key, value))
    .map(([key, value]) => ({
      [valueKey]: key,
      [labelKey]: value,
    }));

  // 排序
  switch (sortBy) {
    case 'key':
      result = result.sort((a, b) => {
        const aKey = a[valueKey];
        const bKey = b[valueKey];
        return typeof aKey === 'number' && typeof bKey === 'number'
          ? aKey - bKey
          : String(aKey).localeCompare(String(bKey));
      });
      break;
    case 'value':
      result = result.sort((a, b) => {
        const aLabel = a[labelKey];
        const bLabel = b[labelKey];
        return String(aLabel).localeCompare(String(bLabel));
      });
      break;
    case 'none':
    default:
      // 不排序
      break;
  }

  return result;
}

/**
 * 使用示例：
 *
 * // 1. 基本使用 - 将对象转换为选项数组
 * const STATUS_MAP = {
 *   1: '正常',
 *   2: '异常',
 *   3: '待处理'
 * };
 *
 * const STATUS_OPTIONS = mapToOptions(STATUS_MAP);
 * // 结果: [
 * //   { label: '正常', value: 1 },
 * //   { label: '异常', value: 2 },
 * //   { label: '待处理', value: 3 }
 * // ]
 *
 * // 2. 自定义字段名
 * const CUSTOM_OPTIONS = mapToOptions(STATUS_MAP, {
 *   valueKey: 'id',
 *   labelKey: 'name'
 * });
 * // 结果: [
 * //   { name: '正常', id: 1 },
 * //   { name: '异常', id: 2 },
 * //   { name: '待处理', id: 3 }
 * // ]
 *
 * // 3. 按 key 排序
 * const SORTED_OPTIONS = mapToOptions(STATUS_MAP, {
 *   sortBy: 'key'
 * });
 *
 * // 4. 按 value 排序
 * const SORTED_BY_VALUE = mapToOptions(STATUS_MAP, {
 *   sortBy: 'value'
 * });
 *
 * // 5. 过滤某些选项
 * const FILTERED_OPTIONS = mapToOptions(STATUS_MAP, {
 *   filter: (key, value) => key !== 2 // 排除 key 为 2 的选项
 * });
 */

/**
 * 创建请求参数过滤器（默认配置）
 * 过滤掉常见的空值，保留有意义的 0 和 false
 */
export function createRequestParams<T extends Record<string, any>>(params: T): Partial<T> {
  return filterEmptyValues(params, {
    filterEmptyString: true,
    filterNull: true,
    filterUndefined: true,
    filterZero: false, // 保留 0，因为 0 可能是有效的参数值
    filterFalse: false, // 保留 false，因为 false 可能是有效的参数值
    filterEmptyArray: true,
    filterEmptyObject: true,
  });
}

// 节流函数：func 在 delay 毫秒内只会被调用一次
export function throttle<T extends (...args: any[]) => any>(func: T, delay: number): T {
  let lastCall = 0;
  let timeout: ReturnType<typeof setTimeout> | null = null;
  let lastArgs: any;
  return function (this: any, ...args: any[]) {
    const now = Date.now();
    lastArgs = args;
    if (now - lastCall >= delay) {
      lastCall = now;
      func.apply(this, args);
    } else if (!timeout) {
      timeout = setTimeout(() => {
        lastCall = Date.now();
        timeout = null;
        func.apply(this, lastArgs);
      }, delay - (now - lastCall));
    }
  } as T;
}

